import Sortable from 'sortablejs';

export function checkMinor() {
    let user = JSON.parse(localStorage.getItem('user'));
    if (user.currentManageDptId != 1) {
        this.$eduAlert('请切换管理部门进行操作', '提示', {
            confirmButtonText: '确定',
            type: 'warning'
        });
        return false;
    } else {
        return true;
    }
}
/**
 * 支持上下拖动排序
 * 说明：
 *  1.这里使用domKey重新渲染，因为拖动后虽然列表改变，但子元素dom可能重复使用，导致结构排序混乱
 *  2.拖动后，重新渲染，dom需要重新绑定sortable
 *  3.目前仅一个业务使用，后期根据场景优化代码
 * @param {*指定dom元素的选择器，其子元素可拖拽移动,如.el-table__body-wrapper tbody，对tr支持拖动} querySelector
 * @param {*组件引用} _this
 * @param {*集合的属性名} listAttrName
 * @param {*dom元素的key，每次拖动改变值，重新渲染} domKey
 * @param {* .el-main中滚动条顶部距离} scrollTop
 * @param {*集合项的排序属性} orderAttr
 * @param {*单位：ms，定义排序动画的时间} animationTime
 */
export function sorttable(
    querySelector,
    _this,
    listAttrName,
    domKey,
    scrollTop = null,
    orderAttr = 'order_',
    animationTime = 150
) {
    let dom = document.querySelector(querySelector);
    let currentScrollTop = null;
    if (scrollTop != null) {
        let main = document.querySelectorAll('.el-main');
        if (main && main.length > 0) {
            main[0].scrollTop = scrollTop;
        }
    }
    new Sortable(dom, {
        animation: animationTime,
        onStart: function () {
            let main = document.querySelectorAll('.el-main');
            if (main && main.length > 0) {
                currentScrollTop = main[0].scrollTop;
            }
        },
        onEnd: function (evt) {
            if (evt.oldIndex === evt.newIndex) {
                return;
            }
            // console.log(evt.oldIndex, evt.newIndex);
            if (evt.oldIndex < evt.newIndex) {
                _this[listAttrName].forEach(row => {
                    if (row[orderAttr] > evt.oldIndex && row[orderAttr] <= evt.newIndex) {
                        row[orderAttr] = row[orderAttr] - 1;
                    }
                });
            } else {
                _this[listAttrName].forEach(row => {
                    if (row[orderAttr] < evt.oldIndex && row[orderAttr] >= evt.newIndex) {
                        row[orderAttr] = row[orderAttr] + 1;
                    }
                });
            }
            _this[listAttrName][evt.oldIndex][orderAttr] = evt.newIndex;
            // 设置排序值后，重新设置集合
            _this[listAttrName] = _.sortBy(_this[listAttrName], [orderAttr]);
            // 重新渲染
            _this[domKey] = new Date();
            // 重新绑定
            _this.$nextTick(() => {
                sorttable(querySelector,
                    _this,
                    listAttrName,
                    domKey,
                    currentScrollTop,
                    orderAttr,
                    animationTime);
            });
        }
    });
}

// 嵌套拖拽
export function sortNestedTable(selector, _this, listAttrName, expandListData, domKey) {
    const dom = document.querySelector(selector);
    new Sortable(dom, {
        fallbackOnBody: true,
        filter: '.el-table__expanded-cell', // 不需要拖拽的元素
        // handle: '.el-table-column--selection', // 控制只能通过选择框来拖拽
        animation: 150,
        onStart: function () {
            // console.log(evt.oldIndex);
        },
        onEnd: function (evt) {
            if (evt.oldIndex === evt.newIndex) {
                return;
            }
            if (listAttrName) {
                let oldIndex = evt.oldIndex;
                let newIndex = evt.newIndex;
                // 扩展列展开时，sortable插件返回的列表index会加1，需要手动修正
                if (_this.expandRowKeysInter.length) {
                    let oldExpandIndex = 0; // 原扩展列index
                    _this[listAttrName].forEach((item, index) => {
                        if (item.directionList && item.directionList.length) {
                            oldExpandIndex = index;
                        }
                    });
                    // evt.oldIndex 和 evt.newIndex 大于 oldExpandIndex 时，手动减1
                    if (evt.oldIndex > oldExpandIndex) {
                        oldIndex -= 1;
                    }
                    if (evt.newIndex > oldExpandIndex) {
                        newIndex -= 1;
                    }
                }
                const currRow = _this[listAttrName].splice(oldIndex, 1)[0]; // 原位置删除数据
                _this[listAttrName].splice(newIndex, 0, currRow); // 新位置插入数据
            } else {
                const currRow = expandListData.splice(evt.oldIndex, 1)[0];
                expandListData.splice(evt.newIndex, 0, currRow);
            }
            // 扩展列展开时，重新绑定嵌套拖拽
            if (_this.expandRowKeysInter.length > 0) {
                _this['directionListInter'] = new Date();
                _this.$nextTick(() => {
                    sortNestedTable('.drag-expand-inter .el-table__body-wrapper tbody', _this, '', _this.directionList, 'directionListInter');
                });
            } else if (_this.expandRowKeysCross.length > 0) {
                _this['directionListCross'] = new Date();
                _this.$nextTick(() => {
                    sortNestedTable('.drag-expand-cross .el-table__body-wrapper tbody', _this, '', _this.directionList, 'directionListCross');
                });
            }
            // 重新渲染;
            _this[domKey] = new Date();
            // 重新绑定
            _this.$nextTick(() => {
                sortNestedTable(selector, _this, listAttrName, expandListData, domKey);
            });
        }
    });
}
